home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / cpu / m6809 / 6809dasm.c next >
C/C++ Source or Header  |  1999-08-02  |  25KB  |  718 lines
  1. /* this code was hacked out of the fully-featured 6809 disassembler by Sean Riddle */
  2.  
  3.  
  4. /* 6809dasm.c - a 6809 opcode disassembler */
  5. /* Version 1.4 1-MAR-95 */
  6. /* Copyright © 1995 Sean Riddle */
  7.  
  8. /* thanks to Franklin Bowen for bug fixes, ideas */
  9.  
  10. /* Freely distributable on any medium given all copyrights are retained */
  11. /* by the author and no charge greater than $7.00 is made for obtaining */
  12. /* this software */
  13.  
  14. /* Please send all bug reports, update ideas and data files to: */
  15. /* sriddle@ionet.net */
  16. #include <stdio.h>
  17.  
  18. #ifdef MAME_DEBUG
  19.  
  20. #include <strings.h>
  21. #include "osd_cpu.h"
  22. #include "cpuintrf.h"
  23. #include "mamedbg.h"
  24. #include "m6809.h"
  25.  
  26. #ifndef TRUE
  27. #define TRUE    -1
  28. #define FALSE    0
  29. #endif
  30.  
  31. typedef struct {                /* opcode structure */
  32.    UINT8    opcode;             /* 8-bit opcode value */
  33.    UINT8    numoperands;
  34.    char     name[6];            /* opcode name */
  35.    UINT8    mode;                /* addressing mode */
  36.    UINT8    size;                /* access size */
  37.    UINT8    access;             /* access mode */
  38.    UINT8    numcycles;            /* number of cycles - not used */
  39. } opcodeinfo;
  40.  
  41. /* 6809 ADDRESSING MODES */
  42. enum M6809_ADDRESSING_MODES {
  43.     INH,
  44.     DIR,
  45.     IND,
  46.     REL,
  47.     EXT,
  48.     IMM,
  49.     LREL,
  50.     PG2,                        /* PAGE SWITCHES -    Page 2 */
  51.     PG3                         /*                    Page 3 */
  52. };
  53.  
  54. /* number of opcodes in each page */
  55. #define NUMPG1OPS 223
  56. #define NUMPG2OPS 38
  57. #define NUMPG3OPS 9
  58.  
  59. int numops[3] =
  60. {
  61.    NUMPG1OPS,NUMPG2OPS,NUMPG3OPS,
  62. };
  63.  
  64. #if 0
  65. static char modenames[9][14] = {
  66.    "inherent",
  67.    "direct",
  68.    "indexed",
  69.    "relative",
  70.    "extended",
  71.    "immediate",
  72.    "long relative",
  73.    "page 2",
  74.    "page 3",
  75. };
  76. #endif
  77.  
  78. /* page 1 ops */
  79. static opcodeinfo pg1opcodes[NUMPG1OPS] =
  80. {
  81.     {  0,1,"NEG",     DIR, EA_UINT8, EA_ZPG_RDWR,  6},
  82.     {  3,1,"COM",     DIR, EA_UINT8, EA_ZPG_RDWR,  6},
  83.     {  4,1,"LSR",     DIR, EA_UINT8, EA_ZPG_RDWR,  6},
  84.     {  6,1,"ROR",     DIR, EA_UINT8, EA_ZPG_RDWR,  6},
  85.     {  7,1,"ASR",     DIR, EA_UINT8, EA_ZPG_RDWR,  6},
  86.     {  8,1,"ASL",     DIR, EA_UINT8, EA_ZPG_RDWR,  6},
  87.     {  9,1,"ROL",     DIR, EA_UINT8, EA_ZPG_RDWR,  6},
  88.     { 10,1,"DEC",     DIR, EA_UINT8, EA_ZPG_RDWR,  6},
  89.     { 12,1,"INC",     DIR, EA_UINT8, EA_ZPG_RDWR,  6},
  90.     { 13,1,"TST",     DIR, EA_UINT8, EA_ZPG_RDWR,  6},
  91.     { 14,1,"JMP",     DIR, EA_UINT8, EA_ABS_PC,    3},
  92.     { 15,1,"CLR",     DIR, EA_UINT8, EA_ZPG_WR,    6},
  93.  
  94.     { 16,1,"page2",   PG2, 0,        0,            0},
  95.     { 17,1,"page3",   PG3, 0,        0,            0},
  96.     { 18,0,"NOP",     INH, 0,        0,            2},
  97.     { 19,0,"SYNC",    INH, 0,        0,            4},
  98.     { 22,2,"LBRA",    LREL,EA_INT16, EA_REL_PC,    5},
  99.     { 23,2,"LBSR",    LREL,EA_INT16, EA_REL_PC,    9},
  100.     { 25,0,"DAA",     INH, 0,        0,            2},
  101.     { 26,1,"ORCC",    IMM, 0,        0,            3},
  102.     { 28,1,"ANDCC",   IMM, 0,        0,            3},
  103.     { 29,0,"SEX",     INH, 0,        0,            2},
  104.     { 30,1,"EXG",     IMM, 0,        0,            8},
  105.     { 31,1,"TFR",     IMM, 0,        0,            6},
  106.  
  107.     { 32,1,"BRA",     REL, EA_INT8,  EA_REL_PC,    3},
  108.     { 33,1,"BRN",     REL, EA_INT8,  EA_REL_PC,    3},
  109.     { 34,1,"BHI",     REL, EA_INT8,  EA_REL_PC,    3},
  110.     { 35,1,"BLS",     REL, EA_INT8,  EA_REL_PC,    3},
  111.     { 36,1,"BCC",     REL, EA_INT8,  EA_REL_PC,    3},
  112.     { 37,1,"BCS",     REL, EA_INT8,  EA_REL_PC,    3},
  113.     { 38,1,"BNE",     REL, EA_INT8,  EA_REL_PC,    3},
  114.     { 39,1,"BEQ",     REL, EA_INT8,  EA_REL_PC,    3},
  115.     { 40,1,"BVC",     REL, EA_INT8,  EA_REL_PC,    3},
  116.     { 41,1,"BVS",     REL, EA_INT8,  EA_REL_PC,    3},
  117.     { 42,1,"BPL",     REL, EA_INT8,  EA_REL_PC,    3},
  118.     { 43,1,"BMI",     REL, EA_INT8,  EA_REL_PC,    3},
  119.     { 44,1,"BGE",     REL, EA_INT8,  EA_REL_PC,    3},
  120.     { 45,1,"BLT",     REL, EA_INT8,  EA_REL_PC,    3},
  121.     { 46,1,"BGT",     REL, EA_INT8,  EA_REL_PC,    3},
  122.     { 47,1,"BLE",     REL, EA_INT8,  EA_REL_PC,    3},
  123.  
  124.     { 48,1,"LEAX",    IND, EA_UINT16,EA_VALUE,     2},
  125.     { 49,1,"LEAY",    IND, EA_UINT16,EA_VALUE,     2},
  126.     { 50,1,"LEAS",    IND, EA_UINT16,EA_VALUE,     2},
  127.     { 51,1,"LEAU",    IND, EA_UINT16,EA_VALUE,     2},
  128.     { 52,1,"PSHS",    INH, 0,        0,            5},
  129.     { 53,1,"PULS",    INH, 0,        0,            5},
  130.     { 54,1,"PSHU",    INH, 0,        0,            5},
  131.     { 55,1,"PULU",    INH, 0,        0,            5},
  132.     { 57,0,"RTS",     INH, 0,        0,            5},
  133.     { 58,0,"ABX",     INH, 0,        0,            3},
  134.     { 59,0,"RTI",     INH, 0,        0,            6},
  135.     { 60,1,"CWAI",    IMM, 0,        0,           20},
  136.     { 61,0,"MUL",     INH, 0,        0,           11},
  137.     { 63,0,"SWI",     INH, 0,        0,           19},
  138.  
  139.     { 64,0,"NEGA",    INH, 0,        0,            2},
  140.     { 67,0,"COMA",    INH, 0,        0,            2},
  141.     { 68,0,"LSRA",    INH, 0,        0,            2},
  142.     { 70,0,"RORA",    INH, 0,        0,            2},
  143.     { 71,0,"ASRA",    INH, 0,        0,            2},
  144.     { 72,0,"ASLA",    INH, 0,        0,            2},
  145.     { 73,0,"ROLA",    INH, 0,        0,            2},
  146.     { 74,0,"DECA",    INH, 0,        0,            2},
  147.     { 76,0,"INCA",    INH, 0,        0,            2},
  148.     { 77,0,"TSTA",    INH, 0,        0,            2},
  149.     { 79,0,"CLRA",    INH, 0,        0,            2},
  150.  
  151.     { 80,0,"NEGB",    INH, 0,        0,            2},
  152.     { 83,0,"COMB",    INH, 0,        0,            2},
  153.     { 84,0,"LSRB",    INH, 0,        0,            2},
  154.     { 86,0,"RORB",    INH, 0,        0,            2},
  155.     { 87,0,"ASRB",    INH, 0,        0,            2},
  156.     { 88,0,"ASLB",    INH, 0,        0,            2},
  157.     { 89,0,"ROLB",    INH, 0,        0,            2},
  158.     { 90,0,"DECB",    INH, 0,        0,            2},
  159.     { 92,0,"INCB",    INH, 0,        0,            2},
  160.     { 93,0,"TSTB",    INH, 0,        0,            2},
  161.     { 95,0,"CLRB",    INH, 0,        0,            2},
  162.  
  163.     { 96,1,"NEG",     IND, EA_UINT8, EA_MEM_RDWR,  6},
  164.     { 99,1,"COM",     IND, EA_UINT8, EA_MEM_RDWR,  6},
  165.     {100,1,"LSR",     IND, EA_UINT8, EA_MEM_RDWR,  6},
  166.     {102,1,"ROR",     IND, EA_UINT8, EA_MEM_RDWR,  6},
  167.     {103,1,"ASR",     IND, EA_UINT8, EA_MEM_RDWR,  6},
  168.     {104,1,"ASL",     IND, EA_UINT8, EA_MEM_RDWR,  6},
  169.     {105,1,"ROL",     IND, EA_UINT8, EA_MEM_RDWR,  6},
  170.     {106,1,"DEC",     IND, EA_UINT8, EA_MEM_RDWR,  6},
  171.     {108,1,"INC",     IND, EA_UINT8, EA_MEM_RDWR,  6},
  172.     {109,1,"TST",     IND, EA_UINT8, EA_MEM_RD,    6},
  173.     {110,1,"JMP",     IND, EA_UINT8, EA_ABS_PC,    3},
  174.     {111,1,"CLR",     IND, EA_UINT8, EA_MEM_WR,    6},
  175.  
  176.     {112,2,"NEG",     EXT, EA_UINT8, EA_MEM_RDWR,  7},
  177.     {115,2,"COM",     EXT, EA_UINT8, EA_MEM_RDWR,  7},
  178.     {116,2,"LSR",     EXT, EA_UINT8, EA_MEM_RDWR,  7},
  179.     {118,2,"ROR",     EXT, EA_UINT8, EA_MEM_RDWR,  7},
  180.     {119,2,"ASR",     EXT, EA_UINT8, EA_MEM_RDWR,  7},
  181.     {120,2,"ASL",     EXT, EA_UINT8, EA_MEM_RDWR,  7},
  182.     {121,2,"ROL",     EXT, EA_UINT8, EA_MEM_RDWR,  7},
  183.     {122,2,"DEC",     EXT, EA_UINT8, EA_MEM_RDWR,  7},
  184.     {124,2,"INC",     EXT, EA_UINT8, EA_MEM_RDWR,  7},
  185.     {125,2,"TST",     EXT, EA_UINT8, EA_MEM_RD,    7},
  186.     {126,2,"JMP",     EXT, EA_UINT8, EA_ABS_PC,    4},
  187.     {127,2,"CLR",     EXT, EA_UINT8, EA_MEM_WR,    7},
  188.  
  189.     {128,1,"SUBA",    IMM, EA_UINT8, EA_VALUE,     2},
  190.     {129,1,"CMPA",    IMM, EA_UINT8, EA_VALUE,     2},
  191.     {130,1,"SBCA",    IMM, EA_UINT8, EA_VALUE,     2},
  192.     {131,2,"SUBD",    IMM, EA_UINT16,EA_VALUE,     4},
  193.     {132,1,"ANDA",    IMM, EA_UINT8, EA_VALUE,     2},
  194.     {133,1,"BITA",    IMM, EA_UINT8, EA_VALUE,     2},
  195.     {134,1,"LDA",     IMM, EA_UINT8, EA_VALUE,     2},
  196.     {136,1,"EORA",    IMM, EA_UINT8, EA_VALUE,     2},
  197.     {137,1,"ADCA",    IMM, EA_UINT8, EA_VALUE,     2},
  198.     {138,1,"ORA",     IMM, EA_UINT8, EA_VALUE,     2},
  199.     {139,1,"ADDA",    IMM, EA_UINT8, EA_VALUE,     2},
  200.     {140,2,"CMPX",    IMM, EA_UINT16,EA_VALUE,     4},
  201.     {141,1,"BSR",     REL, EA_INT8,  EA_REL_PC,    7},
  202.     {142,2,"LDX",     IMM, EA_UINT16,EA_VALUE,     3},
  203.  
  204.     {144,1,"SUBA",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  205.     {145,1,"CMPA",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  206.     {146,1,"SBCA",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  207.     {147,1,"SUBD",    DIR, EA_UINT16,EA_ZPG_RD,    6},
  208.     {148,1,"ANDA",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  209.     {149,1,"BITA",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  210.     {150,1,"LDA",     DIR, EA_UINT8, EA_ZPG_RD,    4},
  211.     {151,1,"STA",     DIR, EA_UINT8, EA_ZPG_WR,    4},
  212.     {152,1,"EORA",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  213.     {153,1,"ADCA",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  214.     {154,1,"ORA",     DIR, EA_UINT8, EA_ZPG_RD,    4},
  215.     {155,1,"ADDA",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  216.     {156,1,"CPX",     DIR, EA_UINT16,EA_ZPG_RD,    6},
  217.     {157,1,"JSR",     DIR, EA_UINT8, EA_ABS_PC,    7},
  218.     {158,1,"LDX",     DIR, EA_UINT16,EA_ZPG_RD,    5},
  219.     {159,1,"STX",     DIR, EA_UINT16,EA_ZPG_WR,    5},
  220.  
  221.     {160,1,"SUBA",    IND, EA_UINT8, EA_MEM_RD,    4},
  222.     {161,1,"CMPA",    IND, EA_UINT8, EA_MEM_RD,    4},
  223.     {162,1,"SBCA",    IND, EA_UINT8, EA_MEM_RD,    4},
  224.     {163,1,"SUBD",    IND, EA_UINT16,EA_MEM_RD,    6},
  225.     {164,1,"ANDA",    IND, EA_UINT8, EA_MEM_RD,    4},
  226.     {165,1,"BITA",    IND, EA_UINT8, EA_MEM_RD,    4},
  227.     {166,1,"LDA",     IND, EA_UINT8, EA_MEM_RD,    4},
  228.     {167,1,"STA",     IND, EA_UINT8, EA_MEM_WR,    4},
  229.     {168,1,"EORA",    IND, EA_UINT8, EA_MEM_RD,    4},
  230.     {169,1,"ADCA",    IND, EA_UINT8, EA_MEM_RD,    4},
  231.     {170,1,"ORA",     IND, EA_UINT8, EA_MEM_RD,    4},
  232.     {171,1,"ADDA",    IND, EA_UINT8, EA_MEM_RD,    4},
  233.     {172,1,"CPX",     IND, EA_UINT16,EA_MEM_RD,    6},
  234.     {173,1,"JSR",     IND, EA_UINT8, EA_ABS_PC,    7},
  235.     {174,1,"LDX",     IND, EA_UINT16,EA_MEM_RD,    5},
  236.     {175,1,"STX",     IND, EA_UINT16,EA_MEM_WR,    5},
  237.  
  238.     {176,2,"SUBA",    EXT, EA_UINT8, EA_MEM_RD,    5},
  239.     {177,2,"CMPA",    EXT, EA_UINT8, EA_MEM_RD,    5},
  240.     {178,2,"SBCA",    EXT, EA_UINT8, EA_MEM_RD,    5},
  241.     {179,2,"SUBD",    EXT, EA_UINT16,EA_MEM_RD,    7},
  242.     {180,2,"ANDA",    EXT, EA_UINT8, EA_MEM_RD,    5},
  243.     {181,2,"BITA",    EXT, EA_UINT8, EA_MEM_RD,    5},
  244.     {182,2,"LDA",     EXT, EA_UINT8, EA_MEM_RD,    5},
  245.     {183,2,"STA",     EXT, EA_UINT8, EA_MEM_WR,    5},
  246.     {184,2,"EORA",    EXT, EA_UINT8, EA_MEM_RD,    5},
  247.     {185,2,"ADCA",    EXT, EA_UINT8, EA_MEM_RD,    5},
  248.     {186,2,"ORA",     EXT, EA_UINT8, EA_MEM_RD,    5},
  249.     {187,2,"ADDA",    EXT, EA_UINT8, EA_MEM_RD,    5},
  250.     {188,2,"CPX",     EXT, EA_UINT16,EA_MEM_RD,    7},
  251.     {189,2,"JSR",     EXT, EA_UINT8, EA_ABS_PC,    8},
  252.     {190,2,"LDX",     EXT, EA_UINT16,EA_MEM_RD,    6},
  253.     {191,2,"STX",     EXT, EA_UINT16,EA_MEM_WR,    6},
  254.  
  255.     {192,1,"SUBB",    IMM, EA_UINT8, EA_VALUE,     2},
  256.     {193,1,"CMPB",    IMM, EA_UINT8, EA_VALUE,     2},
  257.     {194,1,"SBCB",    IMM, EA_UINT8, EA_VALUE,     2},
  258.     {195,2,"ADDD",    IMM, EA_UINT16,EA_VALUE,     4},
  259.     {196,1,"ANDB",    IMM, EA_UINT8, EA_VALUE,     2},
  260.     {197,1,"BITB",    IMM, EA_UINT8, EA_VALUE,     2},
  261.     {198,1,"LDB",     IMM, EA_UINT8, EA_VALUE,     2},
  262.     {200,1,"EORB",    IMM, EA_UINT8, EA_VALUE,     2},
  263.     {201,1,"ADCB",    IMM, EA_UINT8, EA_VALUE,     2},
  264.     {202,1,"ORB",     IMM, EA_UINT8, EA_VALUE,     2},
  265.     {203,1,"ADDB",    IMM, EA_UINT8, EA_VALUE,     2},
  266.     {204,2,"LDD",     IMM, EA_UINT16,EA_VALUE,     3},
  267.     {206,2,"LDU",     IMM, EA_UINT16,EA_VALUE,     3},
  268.  
  269.     {208,1,"SUBB",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  270.     {209,1,"CMPB",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  271.     {210,1,"SBCB",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  272.     {211,1,"ADDD",    DIR, EA_UINT8, EA_ZPG_RD,    6},
  273.     {212,1,"ANDB",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  274.     {213,1,"BITB",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  275.     {214,1,"LDB",     DIR, EA_UINT8, EA_ZPG_RD,    4},
  276.     {215,1,"STB",     DIR, EA_UINT8, EA_ZPG_WR,    4},
  277.     {216,1,"EORB",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  278.     {217,1,"ADCB",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  279.     {218,1,"ORB",     DIR, EA_UINT8, EA_ZPG_RD,    4},
  280.     {219,1,"ADDB",    DIR, EA_UINT8, EA_ZPG_RD,    4},
  281.     {220,1,"LDD",     DIR, EA_UINT16,EA_ZPG_RD,    5},
  282.     {221,1,"STD",     DIR, EA_UINT16,EA_ZPG_WR,    5},
  283.     {222,1,"LDU",     DIR, EA_UINT16,EA_ZPG_RD,    5},
  284.     {223,1,"STU",     DIR, EA_UINT16,EA_ZPG_WR,    5},
  285.  
  286.     {224,1,"SUBB",    IND, EA_UINT8, EA_MEM_RD,    4},
  287.     {225,1,"CMPB",    IND, EA_UINT8, EA_MEM_RD,    4},
  288.     {226,1,"SBCB",    IND, EA_UINT8, EA_MEM_RD,    4},
  289.     {227,1,"ADDD",    IND, EA_UINT8, EA_MEM_RD,    6},
  290.     {228,1,"ANDB",    IND, EA_UINT8, EA_MEM_RD,    4},
  291.     {229,1,"BITB",    IND, EA_UINT8, EA_MEM_RD,    4},
  292.     {230,1,"LDB",     IND, EA_UINT8, EA_MEM_RD,    4},
  293.     {231,1,"STB",     IND, EA_UINT8, EA_MEM_WR,    4},
  294.     {232,1,"EORB",    IND, EA_UINT8, EA_MEM_RD,    4},
  295.     {233,1,"ADCB",    IND, EA_UINT8, EA_MEM_RD,    4},
  296.     {234,1,"ORB",     IND, EA_UINT8, EA_MEM_RD,    4},
  297.     {235,1,"ADDB",    IND, EA_UINT8, EA_MEM_RD,    4},
  298.     {236,1,"LDD",     IND, EA_UINT16,EA_MEM_RD,    5},
  299.     {237,1,"STD",     IND, EA_UINT16,EA_MEM_WR,    5},
  300.     {238,1,"LDU",     IND, EA_UINT16,EA_MEM_RD,    5},
  301.     {239,1,"STU",     IND, EA_UINT16,EA_MEM_WR,    5},
  302.  
  303.     {240,2,"SUBB",    EXT, EA_UINT8, EA_MEM_RD,    5},
  304.     {241,2,"CMPB",    EXT, EA_UINT8, EA_MEM_RD,    5},
  305.     {242,2,"SBCB",    EXT, EA_UINT8, EA_MEM_RD,    5},
  306.     {243,2,"ADDD",    EXT, EA_UINT8, EA_MEM_RD,    7},
  307.     {244,2,"ANDB",    EXT, EA_UINT8, EA_MEM_RD,    5},
  308.     {245,2,"BITB",    EXT, EA_UINT8, EA_MEM_RD,    5},
  309.     {246,2,"LDB",     EXT, EA_UINT8, EA_MEM_RD,    5},
  310.     {247,2,"STB",     EXT, EA_UINT8, EA_MEM_WR,    5},
  311.     {248,2,"EORB",    EXT, EA_UINT8, EA_MEM_RD,    5},
  312.     {249,2,"ADCB",    EXT, EA_UINT8, EA_MEM_RD,    5},
  313.     {250,2,"ORB",     EXT, EA_UINT8, EA_MEM_RD,    5},
  314.     {251,2,"ADDB",    EXT, EA_UINT8, EA_MEM_RD,    5},
  315.     {252,2,"LDD",     EXT, EA_UINT16,EA_MEM_RD,    6},
  316.     {253,2,"STD",     EXT, EA_UINT16,EA_MEM_WR,    6},
  317.     {254,2,"LDU",     EXT, EA_UINT16,EA_MEM_RD,    6},
  318.     {255,2,"STU",     EXT, EA_UINT16,EA_MEM_WR,    6},
  319. };
  320.  
  321. /* page 2 ops 10xx*/
  322. static opcodeinfo pg2opcodes[NUMPG2OPS] =
  323. {
  324.     { 33,3,"LBRN",    LREL,EA_INT16, EA_REL_PC,    5},
  325.     { 34,3,"LBHI",    LREL,EA_INT16, EA_REL_PC,    5},
  326.     { 35,3,"LBLS",    LREL,EA_INT16, EA_REL_PC,    5},
  327.     { 36,3,"LBCC",    LREL,EA_INT16, EA_REL_PC,    5},
  328.     { 37,3,"LBCS",    LREL,EA_INT16, EA_REL_PC,    5},
  329.     { 38,3,"LBNE",    LREL,EA_INT16, EA_REL_PC,    5},
  330.     { 39,3,"LBEQ",    LREL,EA_INT16, EA_REL_PC,    5},
  331.     { 40,3,"LBVC",    LREL,EA_INT16, EA_REL_PC,    5},
  332.     { 41,3,"LBVS",    LREL,EA_INT16, EA_REL_PC,    5},
  333.     { 42,3,"LBPL",    LREL,EA_INT16, EA_REL_PC,    5},
  334.     { 43,3,"LBMI",    LREL,EA_INT16, EA_REL_PC,    5},
  335.     { 44,3,"LBGE",    LREL,EA_INT16, EA_REL_PC,    5},
  336.     { 45,3,"LBLT",    LREL,EA_INT16, EA_REL_PC,    5},
  337.     { 46,3,"LBGT",    LREL,EA_INT16, EA_REL_PC,    5},
  338.     { 47,3,"LBLE",    LREL,EA_INT16, EA_REL_PC,    5},
  339.     { 63,2,"SWI2",    INH, 0,        0,           20},
  340.     {131,3,"CMPD",    IMM, EA_UINT16,EA_VALUE,     5},
  341.     {140,3,"CMPY",    IMM, EA_UINT16,EA_VALUE,     5},
  342.     {142,3,"LDY",     IMM, EA_UINT16,EA_VALUE,     4},
  343.     {147,2,"CMPD",    DIR, EA_UINT16,EA_ZPG_RD,    7},
  344.     {156,2,"CMPY",    DIR, EA_UINT16,EA_ZPG_RD,    7},
  345.     {158,2,"LDY",     DIR, EA_UINT16,EA_ZPG_RD,    6},
  346.     {159,2,"STY",     DIR, EA_UINT16,EA_ZPG_RD,    6},
  347.     {163,2,"CMPD",    IND, EA_UINT16,EA_MEM_RD,    7},
  348.     {172,2,"CMPY",    IND, EA_UINT16,EA_MEM_RD,    7},
  349.     {174,2,"LDY",     IND, EA_UINT16,EA_MEM_RD,    6},
  350.     {175,2,"STY",     IND, EA_UINT16,EA_MEM_RD,    6},
  351.     {179,3,"CMPD",    EXT, EA_UINT16,EA_MEM_RD,    8},
  352.     {188,3,"CMPY",    EXT, EA_UINT16,EA_MEM_RD,    8},
  353.     {190,3,"LDY",     EXT, EA_UINT16,EA_MEM_RD,    7},
  354.     {191,3,"STY",     EXT, EA_UINT16,EA_MEM_RD,    7},
  355.     {206,3,"LDS",     IMM, EA_UINT16,EA_VALUE,     4},
  356.     {222,2,"LDS",     DIR, EA_UINT16,EA_ZPG_RD,    6},
  357.     {223,2,"STS",     DIR, EA_UINT16,EA_ZPG_WR,    6},
  358.     {238,2,"LDS",     IND, EA_UINT16,EA_MEM_RD,    6},
  359.     {239,2,"STS",     IND, EA_UINT16,EA_MEM_WR,    6},
  360.     {254,3,"LDS",     EXT, EA_UINT16,EA_MEM_RD,    7},
  361.     {255,3,"STS",     EXT, EA_UINT16,EA_MEM_WR,    7},
  362. };
  363.  
  364. /* page 3 ops 11xx */
  365. static opcodeinfo pg3opcodes[NUMPG3OPS] =
  366. {
  367.     { 63,1,"SWI3",    INH, 0,        0,           20},
  368.     {131,3,"CMPU",    IMM, EA_UINT16,EA_VALUE,     5},
  369.     {140,3,"CMPS",    IMM, EA_UINT16,EA_VALUE,     5},
  370.     {147,2,"CMPU",    DIR, EA_UINT16,EA_ZPG_RD,    7},
  371.     {156,2,"CMPS",    DIR, EA_UINT16,EA_ZPG_RD,    7},
  372.     {163,2,"CMPU",    IND, EA_UINT16,EA_MEM_RD,    7},
  373.     {172,2,"CMPS",    IND, EA_UINT16,EA_MEM_RD,    7},
  374.     {179,3,"CMPU",    EXT, EA_UINT16,EA_MEM_RD,    8},
  375.     {188,3,"CMPS",    EXT, EA_UINT16,EA_MEM_RD,    8},
  376. };
  377.  
  378. static opcodeinfo *pgpointers[3] =
  379. {
  380.    pg1opcodes,pg2opcodes,pg3opcodes,
  381. };
  382.  
  383. static const UINT8 regid_6809[5] = {
  384.     M6809_X, M6809_Y, M6809_U, M6809_S, M6809_PC
  385. };
  386.  
  387. static const char *regs_6809[5] = {
  388.     "X","Y","U","S","PC"
  389. };
  390.  
  391. static const char *teregs[16] = {
  392.     "D","X","Y","U","S","PC","inv","inv",
  393.     "A","B","CC","DP","inv","inv","inv","inv"
  394. };
  395.  
  396. static char *hexstring (int address)
  397. {
  398.     static char labtemp[10];
  399.     sprintf (labtemp, "$%04hX", address);
  400.     return labtemp;
  401. }
  402.  
  403. unsigned Dasm6809 (char *buffer, unsigned pc)
  404. {
  405.     int i, j, k, page, opcode, numoperands, mode, size, access;
  406.     UINT8 operandarray[4];
  407.     const char *sym1, *sym2;
  408.     int rel, pb, offset, reg, pb2;
  409.     unsigned ea = 0;
  410.     int p = 0;
  411.  
  412.     *buffer = '\0';
  413.  
  414.     opcode = cpu_readop(pc+(p++));
  415.     for( i = 0; i < numops[0]; i++ )
  416.         if (pg1opcodes[i].opcode == opcode)
  417.             break;
  418.  
  419.     if( i < numops[0] )
  420.     {
  421.         if( pg1opcodes[i].mode >= PG2 )
  422.         {
  423.             opcode = cpu_readop(pc+(p++));
  424.             page = pg1opcodes[i].mode - PG2 + 1;          /* get page # */
  425.             for( k = 0; k < numops[page]; k++ )
  426.                 if (opcode == pgpointers[page][k].opcode)
  427.                     break;
  428.  
  429.             if( k != numops[page] )
  430.             {    /* opcode found */
  431.                 numoperands = pgpointers[page][k].numoperands - 1;
  432.                 for (j = 0; j < numoperands; j++)
  433.                     operandarray[j] = cpu_readop_arg(pc+(p++));
  434.                 mode = pgpointers[page][k].mode;
  435.                 size = pgpointers[page][k].size;
  436.                 access = pgpointers[page][k].access;
  437.                 buffer += sprintf (buffer, "%-6s", pgpointers[page][k].name);
  438.              }
  439.              else
  440.              {    /* not found in alternate page */
  441.                 strcpy (buffer, "Illegal Opcode");
  442.                 return 2;
  443.              }
  444.         }
  445.         else
  446.         {    /* page 1 opcode */
  447.             numoperands = pg1opcodes[i].numoperands;
  448.             for( j = 0; j < numoperands; j++ )
  449.                 operandarray[j] = cpu_readop_arg(pc+(p++));
  450.             mode = pg1opcodes[i].mode;
  451.             size = pg1opcodes[i].size;
  452.             access = pg1opcodes[i].access;
  453.             buffer += sprintf (buffer, "%-6s", pg1opcodes[i].name);
  454.         }
  455.     }
  456.     else
  457.     {
  458.         strcpy (buffer, "Illegal Opcode");
  459.         return 1;
  460.     }
  461.  
  462.     pc += p;
  463.  
  464.     if( opcode != 0x1f && opcode != 0x1e )
  465.     {
  466.         if( mode == IMM )
  467.             buffer += sprintf (buffer, "#");
  468.     }
  469.  
  470.     switch (mode)
  471.     {
  472.     case REL:      /* 8-bit relative */
  473.         rel = operandarray[0];
  474.         sym1 = set_ea_info(0, pc, (INT8)rel, access);
  475.         buffer += sprintf (buffer, "%s", sym1);
  476.         break;
  477.  
  478.     case LREL:      /* 16-bit long relative */
  479.         rel = (operandarray[0] << 8) + operandarray[1];
  480.         sym1 = set_ea_info(0, pc, (INT16)rel, access);
  481.         buffer += sprintf (buffer, "%s", sym1);
  482.         break;
  483.  
  484.     case IND:      /* indirect- many flavors */
  485.         pb = operandarray[0];
  486.         reg = (pb >> 5) & 3;
  487.         pb2 = pb & 0x8f;
  488.         if( pb2 == 0x88 || pb2 == 0x8c )
  489.         {    /* 8-bit offset */
  490.  
  491.             /* KW 11/05/98 Fix of indirect opcodes        */
  492.             offset = (INT8)cpu_readop_arg(pc);
  493.             p++;
  494.             if( pb == 0x8c ) reg = 4;
  495.             if( (pb & 0x90) == 0x90 ) buffer += sprintf (buffer, "[");
  496.             if( pb == 0x8c )
  497.             {
  498.                 sym1 = set_ea_info(1, pc, (INT8)offset, EA_REL_PC);
  499.                 ea = (pc + (INT8)offset + cpu_get_reg(regid_6809[reg])) & 0xffff;
  500.                 buffer += sprintf (buffer, "%s,%s", sym1, regs_6809[reg]);
  501.             }
  502.             else
  503.             {
  504.                 sym1 = set_ea_info(1, offset, EA_INT8, EA_VALUE);
  505.                 ea = (cpu_get_reg(regid_6809[reg]) + offset) & 0xffff;
  506.                 buffer += sprintf (buffer, "%s,%s", sym1, regs_6809[reg]);
  507.             }
  508. //              if( pb == 0x8c )
  509. //                  buffer += sprintf (buffer, " ; ($%04X)", offset + pc);
  510.         }
  511.         else
  512.         if( pb2 == 0x89 || pb2 == 0x8d || pb2 == 0x8f )
  513.         {    /* 16-bit */
  514.  
  515.             /* KW 11/05/98 Fix of indirect opcodes        */
  516.  
  517.             offset = (INT16)( (cpu_readop_arg(pc) << 8) + cpu_readop_arg(pc+1) );
  518.             p += 2;
  519.  
  520.             if( pb == 0x8d )
  521.                 reg = 4;
  522.             if( (pb&0x90) == 0x90 )
  523.                 buffer += sprintf(buffer, "[");
  524.             if( pb == 0x8d )
  525.             {
  526.                 sym1 = set_ea_info(1, pc, (INT16)offset, EA_REL_PC);
  527.                 buffer += sprintf (buffer, "%s,%s", sym1, regs_6809[reg]);
  528.             }
  529.             else
  530.             {
  531.                 sym1 = set_ea_info(1, offset, EA_INT16, EA_VALUE);
  532.                 ea = (cpu_get_reg(regid_6809[reg]) + offset) & 0xffff;
  533.                 buffer += sprintf (buffer, "%s,%s", sym1, regs_6809[reg]);
  534.             }
  535. //              if( pb == 0x8d )
  536. //                  buffer += sprintf (buffer, " ; ($%04X)", offset + pc);
  537.         }
  538.         else
  539.         if( pb & 0x80 )
  540.         {
  541.             if( (pb & 0x90) == 0x90 )
  542.                 buffer += sprintf (buffer, "[");
  543.             switch( pb & 0x8f )
  544.             {
  545.             case 0x80:
  546.                 ea = cpu_get_reg(regid_6809[reg]);
  547.                 buffer += sprintf (buffer, ",%s+", regs_6809[reg]);
  548.                 break;
  549.             case 0x81:
  550.                 ea = cpu_get_reg(regid_6809[reg]);
  551.                 buffer += sprintf (buffer, ",%s++", regs_6809[reg]);
  552.                 break;
  553.             case 0x82:
  554.                 ea = cpu_get_reg(regid_6809[reg]);
  555.                 buffer += sprintf (buffer, ",-%s", regs_6809[reg]);
  556.                 break;
  557.             case 0x83:
  558.                 ea = cpu_get_reg(regid_6809[reg]);
  559.                 buffer += sprintf (buffer, ",--%s", regs_6809[reg]);
  560.                 break;
  561.             case 0x84:
  562.                 ea = cpu_get_reg(regid_6809[reg]);
  563.                 buffer += sprintf (buffer, ",%s", regs_6809[reg]);
  564.                 break;
  565.             case 0x85:
  566.                 ea = (cpu_get_reg(regid_6809[reg]) + (INT8) cpu_get_reg(M6809_B)) & 0xffff;
  567.                 buffer += sprintf (buffer, "B,%s", regs_6809[reg]);
  568.                 break;
  569.             case 0x86:
  570.                 ea = (cpu_get_reg(regid_6809[reg]) + (INT8) cpu_get_reg(M6809_A)) & 0xffff;
  571.                 buffer += sprintf (buffer, "A,%s", regs_6809[reg]);
  572.                 break;
  573.             case 0x8b:
  574.                 ea = (cpu_get_reg(regid_6809[reg]) + (cpu_get_reg(M6809_A) << 8) + cpu_get_reg(M6809_B)) & 0xffff;
  575.                 buffer += sprintf (buffer, "D,%s", regs_6809[reg]);
  576.                 break;
  577.             }
  578.         }
  579.         else
  580.         {                                           /* 5-bit offset */
  581.             offset = pb & 0x1f;
  582.             if (offset > 15)
  583.                 offset = offset - 32;
  584.             buffer += sprintf (buffer, "%s,%s", hexstring (offset), regs_6809[reg]);
  585.         }
  586.         /* indirect */
  587.         if( (pb & 0x90) == 0x90 )
  588.         {
  589.             ea = ( cpu_readmem16( ea ) << 8 ) + cpu_readmem16( (ea+1) & 0xffff );
  590.             buffer += sprintf (buffer, "]");
  591.         }
  592.         sym2 = set_ea_info(0, ea, size, access);
  593.         break;
  594.  
  595.     default:
  596.         if( opcode == 0x1f || opcode == 0x1e )
  597.         {    /* TFR/EXG */
  598.             buffer += sprintf (buffer, "%s,%s", teregs[ (operandarray[0] >> 4) & 0xf], teregs[operandarray[0] & 0xf]);
  599.         }
  600.         else
  601.         if( opcode == 0x34 || opcode == 0x36 )
  602.         {    /* PUSH */
  603.             pb2 = operandarray[0];
  604.             if( pb2 & 0x80 )
  605.             {
  606.                 buffer += sprintf (buffer, "PC");
  607.             }
  608.             if( pb2 & 0x40 )
  609.             {
  610.                 if( pb2 & 0x80 ) buffer += sprintf (buffer, ",");
  611.                 if( opcode == 0x34 || opcode == 0x35 )
  612.                    buffer += sprintf (buffer, "U");
  613.                 else
  614.                    buffer += sprintf (buffer, "S");
  615.             }
  616.             if( pb2 & 0x20 )
  617.             {
  618.                 if( pb2 & 0xc0 ) buffer += sprintf (buffer, ",");
  619.                 buffer += sprintf (buffer, "Y");
  620.             }
  621.             if( pb2 & 0x10 )
  622.             {
  623.                 if( pb2 & 0xe0 ) buffer += sprintf (buffer, ",");
  624.                 buffer += sprintf (buffer, "X");
  625.             }
  626.             if( pb2 & 0x08 )
  627.             {
  628.                 if( pb2 & 0xf0 ) buffer += sprintf (buffer, ",");
  629.                 buffer += sprintf (buffer, "DP");
  630.             }
  631.             if( pb2 & 0x04 )
  632.             {
  633.                 if( pb2 & 0xf8 ) buffer += sprintf (buffer, ",");
  634.                 buffer += sprintf (buffer, "B");
  635.             }
  636.             if( pb2 & 0x02 )
  637.             {
  638.                 if( pb2 & 0xfc ) buffer += sprintf (buffer, ",");
  639.                 strcat (buffer, "A");
  640.             }
  641.             if( pb2 & 0x01 )
  642.             {
  643.                 if( pb2 & 0xfe ) buffer += sprintf (buffer, ",");
  644.                 strcat (buffer, "CC");
  645.             }
  646.         }
  647.         else
  648.         if( opcode == 0x35 || opcode == 0x37 )
  649.         {    /* PULL */
  650.             pb2 = operandarray[0];
  651.             if( pb2 & 0x01 )
  652.             {
  653.                 buffer += sprintf (buffer, "CC");
  654.             }
  655.             if( pb2 & 0x02 )
  656.             {
  657.                 if( pb2 & 0x01 ) buffer += sprintf (buffer, ",");
  658.                 buffer += sprintf (buffer, "A");
  659.             }
  660.             if( pb2 & 0x04 )
  661.             {
  662.                 if( pb2 & 0x03 ) buffer += sprintf (buffer, ",");
  663.                 buffer += sprintf (buffer, "B");
  664.             }
  665.             if( pb2 & 0x08 )
  666.             {
  667.                 if( pb2 & 0x07 ) buffer += sprintf (buffer, ",");
  668.                 buffer += sprintf (buffer, "DP");
  669.             }
  670.             if( pb2 & 0x10 )
  671.             {
  672.                 if( pb2 & 0x0f ) buffer += sprintf (buffer, ",");
  673.                 buffer += sprintf (buffer, "X");
  674.             }
  675.             if( pb2 & 0x20 )
  676.             {
  677.                 if( pb2 & 0x1f ) buffer += sprintf (buffer, ",");
  678.                 buffer += sprintf (buffer, "Y");
  679.             }
  680.             if( pb2 & 0x40 )
  681.             {
  682.                 if( pb2 & 0x3f ) buffer += sprintf (buffer, ",");
  683.                 if( opcode == 0x34 || opcode == 0x35 )
  684.                     buffer += sprintf (buffer, "U");
  685.                 else
  686.                     buffer += sprintf (buffer, "S");
  687.             }
  688.             if( pb2 & 0x80 )
  689.             {
  690.                 if( pb2 & 0x7f ) buffer += sprintf (buffer, ",");
  691.                 buffer += sprintf (buffer, "PC");
  692.                 buffer += sprintf (buffer, " ; (PUL? PC=RTS)");
  693.             }
  694.         }
  695.         else
  696.         {
  697.             if( numoperands == 2 )
  698.             {
  699.                 ea = (operandarray[0] << 8) + operandarray[1];
  700.                 sym1 = set_ea_info(0, ea, size, access );
  701.                 buffer += sprintf (buffer, "%s", sym1 );
  702.             }
  703.             else
  704.             if( numoperands == 1 )
  705.             {
  706.                 ea = operandarray[0];
  707.                 sym1 = set_ea_info(0, ea, size, access );
  708.                 buffer += sprintf (buffer, "%s", sym1 );
  709.             }
  710.         }
  711.         break;
  712.     }
  713.  
  714.     return p;
  715. }
  716.  
  717. #endif
  718.